import random  # used for generating large random lists
import string  # used for string test cases
import sys  # used for checking recursion limit in edge cases

# imports
import pytest  # used for our unit tests
from code_to_optimize.bubble_sort import sorter

# unit tests

# ------------------------
# 1. Basic Test Cases
# ------------------------

def test_sorter_empty_list():
    # Test sorting an empty list should return an empty list
    codeflash_output = sorter([]) # 5.54μs -> 3.96μs (40.0% faster)

def test_sorter_single_element():
    # Test sorting a single-element list returns the same list
    codeflash_output = sorter([42]) # 5.38μs -> 4.12μs (30.3% faster)

def test_sorter_already_sorted():
    # Test sorting an already sorted list
    codeflash_output = sorter([1, 2, 3, 4, 5]) # 6.08μs -> 4.21μs (44.6% faster)

def test_sorter_reverse_sorted():
    # Test sorting a reverse-sorted list
    codeflash_output = sorter([5, 4, 3, 2, 1]) # 6.46μs -> 4.21μs (53.5% faster)

def test_sorter_unsorted():
    # Test sorting a typical unsorted list
    codeflash_output = sorter([3, 1, 4, 5, 2]) # 5.92μs -> 4.08μs (44.9% faster)

def test_sorter_with_duplicates():
    # Test sorting a list with duplicate elements
    codeflash_output = sorter([4, 2, 2, 3, 1, 4]) # 6.50μs -> 4.29μs (51.4% faster)

def test_sorter_negative_numbers():
    # Test sorting a list with negative and positive numbers
    codeflash_output = sorter([-3, 1, 0, -2, 5]) # 5.92μs -> 4.42μs (33.9% faster)

def test_sorter_all_equal():
    # Test sorting a list where all elements are the same
    codeflash_output = sorter([7, 7, 7, 7]) # 5.29μs -> 4.12μs (28.3% faster)

# ------------------------
# 2. Edge Test Cases
# ------------------------

def test_sorter_large_integers():
    # Test sorting a list with very large integers
    arr = [999999999, -999999999, 0, 123456789, -123456789]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 7.29μs -> 4.75μs (53.5% faster)

def test_sorter_floats():
    # Test sorting a list with float values
    arr = [3.1, 2.2, -1.5, 0.0, 2.2]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 8.12μs -> 5.33μs (52.3% faster)

def test_sorter_strings():
    # Test sorting a list of strings lexicographically
    arr = ["banana", "apple", "cherry", "date"]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 6.38μs -> 4.54μs (40.4% faster)

def test_sorter_mixed_case_strings():
    # Test sorting a list of strings with mixed case
    arr = ["Banana", "apple", "Cherry", "date"]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 5.92μs -> 4.42μs (34.0% faster)

def test_sorter_unicode_strings():
    # Test sorting a list with unicode characters
    arr = ["café", "cafe", "cafè", "cåfe"]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 7.12μs -> 4.96μs (43.7% faster)

def test_sorter_empty_strings():
    # Test sorting a list with empty strings
    arr = ["", "a", "b", ""]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 5.92μs -> 4.25μs (39.2% faster)

def test_sorter_single_char_strings():
    # Test sorting a list of single-character strings
    arr = ["z", "a", "m", "b"]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 5.92μs -> 4.21μs (40.6% faster)


def test_sorter_incomparable_types_error():
    # Test sorting a list with incomparable types should raise TypeError
    arr = [1, "a", 3]
    with pytest.raises(TypeError):
        sorter(arr.copy()) # 4.21μs -> 2.96μs (42.3% faster)

def test_sorter_none_values_error():
    # Test sorting a list with None and integers should raise TypeError
    arr = [None, 1, 2]
    with pytest.raises(TypeError):
        sorter(arr.copy()) # 3.46μs -> 2.75μs (25.7% faster)

def test_sorter_boolean_values():
    # Test sorting a list with boolean values (should sort as 0/1)
    arr = [True, False, True, False]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 6.83μs -> 4.62μs (47.7% faster)

def test_sorter_immutable_input():
    # Test that the function returns a reference to the same list (in-place sort)
    arr = [3, 2, 1]
    codeflash_output = sorter(arr); result = codeflash_output # 5.79μs -> 4.17μs (39.0% faster)

# ------------------------
# 3. Large Scale Test Cases
# ------------------------

def test_sorter_large_sorted_list():
    # Test sorting a large already sorted list
    arr = list(range(1000))
    expected = list(range(1000))
    codeflash_output = sorter(arr.copy()) # 32.5ms -> 52.6μs (61598% faster)

def test_sorter_large_reverse_sorted_list():
    # Test sorting a large reverse-sorted list
    arr = list(range(999, -1, -1))
    expected = list(range(1000))
    codeflash_output = sorter(arr.copy()) # 51.4ms -> 52.2μs (98426% faster)

def test_sorter_large_random_list():
    # Test sorting a large random list of integers
    arr = [random.randint(-10000, 10000) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 46.7ms -> 117μs (39544% faster)

def test_sorter_large_duplicates():
    # Test sorting a large list with many duplicate values
    arr = [random.choice([1, 2, 3, 4, 5]) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 41.5ms -> 91.2μs (45410% faster)

def test_sorter_large_strings():
    # Test sorting a large list of random strings
    arr = [
        ''.join(random.choices(string.ascii_letters, k=5))
        for _ in range(1000)
    ]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 50.9ms -> 136μs (37254% faster)

def test_sorter_large_floats():
    # Test sorting a large list of random floats
    arr = [random.uniform(-10000, 10000) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 45.3ms -> 402μs (11149% faster)

# ------------------------
# Additional Edge Cases
# ------------------------

def test_sorter_minimum_and_maximum():
    # Test sorting a list with only minimum and maximum values
    arr = [float('-inf'), float('inf'), 0, -1, 1]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()) # 8.21μs -> 5.08μs (61.4% faster)

def test_sorter_mutation():
    # Test that the input list is mutated (in-place sort)
    arr = [2, 1]
    sorter(arr) # 5.38μs -> 4.17μs (29.0% faster)

def test_sorter_large_identical_elements():
    # Test sorting a large list with all identical elements
    arr = [42] * 1000
    expected = [42] * 1000
    codeflash_output = sorter(arr.copy()) # 31.5ms -> 50.4μs (62325% faster)

def test_sorter_stability():
    # Test that the sort is stable for objects with equal keys
    # Bubble sort is stable, so relative order should be preserved
    class Item:
        def __init__(self, key, value):
            self.key = key
            self.value = value
        def __lt__(self, other):
            return self.key < other.key
        def __gt__(self, other):
            return self.key > other.key
        def __eq__(self, other):
            return self.key == other.key and self.value == other.value
        def __repr__(self):
            return f"Item({self.key}, {self.value})"
    items = [Item(1, 'a'), Item(2, 'b'), Item(1, 'c'), Item(2, 'd')]
    codeflash_output = sorter(items.copy()); sorted_items = codeflash_output # 8.96μs -> 6.42μs (39.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import random  # used for generating large random lists
import string  # used for string test cases

# imports
import pytest  # used for our unit tests
from code_to_optimize.bubble_sort import sorter

# unit tests

# -----------------------
# Basic Test Cases
# -----------------------

def test_sorter_sorted_list():
    # Already sorted list should remain unchanged
    arr = [1, 2, 3, 4, 5]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 6.96μs -> 4.33μs (60.6% faster)

def test_sorter_reverse_sorted_list():
    # Reverse sorted list should be sorted in ascending order
    arr = [5, 4, 3, 2, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 6.67μs -> 4.21μs (58.4% faster)

def test_sorter_unsorted_list():
    # Unsorted list with mixed values
    arr = [3, 1, 4, 5, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 6.04μs -> 4.21μs (43.6% faster)

def test_sorter_duplicates():
    # List with duplicate elements
    arr = [2, 3, 2, 1, 4, 1]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 6.33μs -> 4.33μs (46.2% faster)

def test_sorter_negative_numbers():
    # List with negative numbers
    arr = [-2, -5, 3, 0, 2]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.79μs -> 4.38μs (32.4% faster)

def test_sorter_single_element():
    # Single element list should remain unchanged
    arr = [42]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.54μs -> 4.08μs (11.2% faster)

def test_sorter_two_elements():
    # Two-element list, both sorted and unsorted
    codeflash_output = sorter([2, 1]) # 4.92μs -> 3.96μs (24.2% faster)
    codeflash_output = sorter([1, 2]) # 4.25μs -> 3.75μs (13.3% faster)

def test_sorter_all_equal():
    # All elements are equal
    arr = [7, 7, 7, 7]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.67μs -> 4.04μs (40.2% faster)

# -----------------------
# Edge Test Cases
# -----------------------

def test_sorter_empty_list():
    # Empty list should remain unchanged
    arr = []
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 4.42μs -> 3.83μs (15.2% faster)

def test_sorter_large_numbers():
    # List with very large and very small integers
    arr = [999999999, -999999999, 0, 123456789, -123456789]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 7.29μs -> 4.75μs (53.5% faster)

def test_sorter_floats():
    # List with float values
    arr = [3.1, 2.2, 5.5, 1.0, 4.8]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 8.21μs -> 5.58μs (47.0% faster)

def test_sorter_mixed_int_float():
    # List with both int and float values
    arr = [1, 3.5, 2, 4.0, 0]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 7.50μs -> 5.17μs (45.2% faster)

def test_sorter_strings():
    # List of strings should be sorted lexicographically
    arr = ["banana", "apple", "cherry"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.58μs -> 4.33μs (28.8% faster)

def test_sorter_empty_strings():
    # List with empty strings
    arr = ["", "a", "abc", ""]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 5.96μs -> 4.38μs (36.2% faster)

def test_sorter_unicode_strings():
    # List with unicode strings
    arr = ["α", "β", "γ", "δ", "α"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 7.46μs -> 5.25μs (42.1% faster)

def test_sorter_case_sensitive_strings():
    # Case-sensitive sorting
    arr = ["apple", "Banana", "banana", "Apple"]
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 6.12μs -> 4.46μs (37.4% faster)

def test_sorter_nested_lists():
    # List with nested lists should raise TypeError (cannot compare list and int)
    arr = [1, [2], 3]
    with pytest.raises(TypeError):
        sorter(arr.copy()) # 3.58μs -> 2.71μs (32.3% faster)

def test_sorter_mixed_types():
    # List with mixed types (int and str) should raise TypeError
    arr = [1, "a", 2]
    with pytest.raises(TypeError):
        sorter(arr.copy()) # 3.08μs -> 2.54μs (21.3% faster)

def test_sorter_none_in_list():
    # List containing None and ints should raise TypeError
    arr = [None, 1, 2]
    with pytest.raises(TypeError):
        sorter(arr.copy()) # 3.00μs -> 2.50μs (20.0% faster)

def test_sorter_mutation():
    # Ensure that the original list passed is mutated (in-place sort)
    arr = [2, 1]
    sorter(arr) # 5.00μs -> 4.12μs (21.2% faster)

# -----------------------
# Large Scale Test Cases
# -----------------------

def test_sorter_large_random_ints():
    # Large list of random integers
    arr = random.sample(range(-10000, -9000), 1000)
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 46.7ms -> 118μs (39141% faster)

def test_sorter_large_sorted():
    # Large already sorted list
    arr = list(range(1000))
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 31.9ms -> 52.4μs (60744% faster)

def test_sorter_large_reverse_sorted():
    # Large reverse sorted list
    arr = list(range(999, -1, -1))
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 51.2ms -> 52.1μs (98252% faster)

def test_sorter_large_duplicates():
    # Large list with many duplicates
    arr = [42] * 1000
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 31.5ms -> 50.3μs (62631% faster)

def test_sorter_large_strings():
    # Large list of random strings
    arr = [''.join(random.choices(string.ascii_letters, k=5)) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 50.9ms -> 136μs (37261% faster)

def test_sorter_large_floats():
    # Large list of random floats
    arr = [random.uniform(-10000, 10000) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 45.2ms -> 401μs (11160% faster)

def test_sorter_large_negative_positive():
    # Large list with both negative and positive numbers
    arr = [random.randint(-10000, 10000) for _ in range(1000)]
    expected = sorted(arr)
    codeflash_output = sorter(arr.copy()); result = codeflash_output # 45.9ms -> 116μs (39474% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.